package main

import (
	"fmt"
	"math"
	"reflect"
	"runtime"
)

/**
 * 2.6函数
 * (1) 函数可以返回多个值
 * (2) 函数返回多个值时可以起名字
 * (3) 仅用于非常简单的函数
 * (4) 对于调用者而言没有区别
 *
 * GO语言 函数式编程语言
 * (1) 函数作为参数
 * GO语言 没有 默认参数 可变参数列表 函数重载 这些复杂花哨的东西,唯一有的是可变参数列表
 * (2) 可变参数列表
 *
 * 函数语法要点回顾
 * (1) 返回值类型写在最后面
 * (2) 可返回多个值
 * (3) 函数作为参数
 * (4) 没有默认参数,可选参数
 */
func main() {
	fmt.Println(eval(3, 4, "*"))
	fmt.Println(div1(13, 3))
	q, r := div2(13, 3)
	fmt.Println(q, r)

	if result, err := eval2(3, 4, "x"); err != nil {
		fmt.Println("Error", err)
	} else {
		fmt.Println(result)
	}

	fmt.Println(apply(pow, 3, 4))

	fmt.Println(apply(
		func(a int, b int) int {
			return int(math.Pow(
				float64(a), float64(b)))
		}, 3, 4))

	fmt.Println(sum(1, 2, 3, 4, 5))
}

// 1.
func eval(a, b int, op string) int {
	switch op {
	case "+":
		return a + b
	case "-":
		return a - b
	case "*":
		return a * b
	case "/":
		//return a / b
		q, _ := div2(a, b)
		return q
	default:
		panic("unsupported operation: " + op)
	}
}

// 2.返回两个值 带余除法 13 / 3 = 4 ... 1
func div1(a, b int) (int, int) {
	return a / b, a % b
}

// 3.返回值取名字
func div2(a, b int) (q, r int) {
	return a / b, a % b
}

// 4.3的第二种写法
func div3(a, b int) (q, r int) {
	q = a / b
	r = a % b
	return
}

//5. 返回err
func eval2(a, b int, op string) (int, error) {
	switch op {
	case "+":
		return a + b, nil
	case "-":
		return a - b, nil
	case "*":
		return a * b, nil
	case "/":
		//return a / b
		q, _ := div2(a, b)
		return q, nil
	default:
		return 0, fmt.Errorf("unsupported operation: %s", op)
	}
}

// 二、可以用函数作为参数
func apply(op func(int, int) int, a, b int) int {
	p := reflect.ValueOf(op).Pointer() // 反射获取
	opName := runtime.FuncForPC(p).Name()
	fmt.Printf("Calling function %s with args "+"(%d, %d)\n", opName, a, b)
	return op(a, b)
}
func pow(a, b int) int {
	return int(math.Pow(float64(a), float64(b)))
}

// 可变参数列表
func sum(numbers ...int) int {
	s := 0
	for i := range numbers {
		s += numbers[i]
	}
	return s
}
